/**
 * 通用工具函数库
 */

/**
 * 格式化日期时间
 * @param {Date|string|number} date 日期对象、时间戳或日期字符串
 * @param {string} format 格式化模板，默认 'YYYY-MM-DD HH:mm:ss'
 * @returns {string} 格式化后的日期字符串
 */
export const formatDate = (date, format = 'YYYY-MM-DD HH:mm:ss') => {
  if (!date) return ''
  
  const d = new Date(date)
  if (isNaN(d.getTime())) return ''
  
  const year = d.getFullYear()
  const month = String(d.getMonth() + 1).padStart(2, '0')
  const day = String(d.getDate()).padStart(2, '0')
  const hours = String(d.getHours()).padStart(2, '0')
  const minutes = String(d.getMinutes()).padStart(2, '0')
  const seconds = String(d.getSeconds()).padStart(2, '0')
  
  return format
    .replace('YYYY', year)
    .replace('MM', month)
    .replace('DD', day)
    .replace('HH', hours)
    .replace('mm', minutes)
    .replace('ss', seconds)
}

/**
 * 格式化相对时间
 * @param {Date|string|number} date 日期
 * @returns {string} 相对时间描述
 */
export const formatRelativeTime = (date) => {
  if (!date) return ''
  
  const now = new Date()
  const targetDate = new Date(date)
  const diff = now.getTime() - targetDate.getTime()
  
  if (diff < 60000) { // 1分钟内
    return '刚刚'
  } else if (diff < 3600000) { // 1小时内
    return `${Math.floor(diff / 60000)}分钟前`
  } else if (diff < 86400000) { // 1天内
    return `${Math.floor(diff / 3600000)}小时前`
  } else if (diff < 2592000000) { // 30天内
    return `${Math.floor(diff / 86400000)}天前`
  } else {
    return formatDate(date, 'MM-DD')
  }
}

/**
 * 格式化距离现在的时间（别名函数，兼容不同命名习惯）
 * @param {Date|string|number} date 日期
 * @returns {string} 相对时间描述
 */
export const formatDistanceToNow = formatRelativeTime

/**
 * 防抖函数
 * @param {Function} func 要防抖的函数
 * @param {number} delay 延迟时间（毫秒）
 * @returns {Function} 防抖后的函数
 */
export const debounce = (func, delay = 300) => {
  let timer = null
  return function (...args) {
    if (timer) clearTimeout(timer)
    timer = setTimeout(() => {
      func.apply(this, args)
    }, delay)
  }
}

/**
 * 节流函数
 * @param {Function} func 要节流的函数
 * @param {number} delay 间隔时间（毫秒）
 * @returns {Function} 节流后的函数
 */
export const throttle = (func, delay = 300) => {
  let timer = null
  return function (...args) {
    if (!timer) {
      timer = setTimeout(() => {
        func.apply(this, args)
        timer = null
      }, delay)
    }
  }
}

/**
 * 深拷贝
 * @param {any} obj 要拷贝的对象
 * @returns {any} 拷贝后的对象
 */
export const deepClone = (obj) => {
  if (obj === null || typeof obj !== 'object') return obj
  if (obj instanceof Date) return new Date(obj.getTime())
  if (obj instanceof Array) return obj.map(item => deepClone(item))
  if (typeof obj === 'object') {
    const copy = {}
    Object.keys(obj).forEach(key => {
      copy[key] = deepClone(obj[key])
    })
    return copy
  }
}

/**
 * 获取图片完整URL
 * @param {string} path 图片路径
 * @returns {string} 完整的图片URL
 */
export const getImageUrl = (path) => {
  if (!path) return ''
  if (path.startsWith('http')) return path
  if (path.startsWith('/')) return path
  return `/static/images/${path}`
}

/**
 * 生成用户头像URL
 * @param {string} username 用户名
 * @returns {string} 头像URL
 */
export const generateAvatarUrl = (username) => {
  // 默认头像URL
  const defaultAvatarUrl = 'https://ts1.tc.mm.bing.net/th/id/OIP-C.4qE6UmzbSk0mCOn2uWMELAAAAA?rs=1&pid=ImgDetMain&o=7&rm=3'

  if (!username) {
    return defaultAvatarUrl
  }

  // 使用 DiceBear API 生成基于用户名的头像
  // 这样每个用户名都会有一个固定的、独特的头像
  try {
    // 使用 avataaars 风格生成头像
    const avatarUrl = `https://api.dicebear.com/7.x/avataaars/svg?seed=${encodeURIComponent(username)}&backgroundColor=b6e3f4,c0aede,d1d4f9,ffd5dc,ffdfbf`
    return avatarUrl
  } catch (error) {
    console.warn('生成头像失败，使用默认头像:', error)
    return defaultAvatarUrl
  }
}

/**
 * 格式化价格
 * @param {number|string} price 价格
 * @param {string} currency 货币符号，默认 '$'
 * @returns {string} 格式化后的价格
 */
export const formatPrice = (price, currency = '$') => {
  if (!price && price !== 0) return `${currency}0.00`
  const num = parseFloat(price)
  if (isNaN(num)) return `${currency}0.00`
  return `${currency}${num.toFixed(2)}`
}

/**
 * 格式化数量
 * @param {number} num 数字
 * @returns {string} 格式化后的数量（如：1K、1.2M）
 */
export const formatNumber = (num) => {
  if (!num && num !== 0) return '0'
  const number = parseInt(num)
  if (number < 1000) return number.toString()
  if (number < 1000000) return (number / 1000).toFixed(1) + 'K'
  return (number / 1000000).toFixed(1) + 'M'
}

/**
 * 验证邮箱格式
 * @param {string} email 邮箱地址
 * @returns {boolean} 是否为有效邮箱
 */
export const validateEmail = (email) => {
  const regex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/
  return regex.test(email)
}

/**
 * 验证手机号格式
 * @param {string} phone 手机号
 * @returns {boolean} 是否为有效手机号
 */
export const validatePhone = (phone) => {
  const regex = /^1[3-9]\d{9}$/
  return regex.test(phone)
}

/**
 * 验证密码强度
 * @param {string} password 密码
 * @returns {object} 验证结果 { valid: boolean, level: string, tips: string[] }
 */
export const validatePassword = (password) => {
  const result = {
    valid: false,
    level: 'weak',
    tips: []
  }
  
  if (!password) {
    result.tips.push('密码不能为空')
    return result
  }
  
  if (password.length < 6) {
    result.tips.push('密码长度至少6位')
  }
  
  if (password.length > 20) {
    result.tips.push('密码长度不能超过20位')
  }
  
  let score = 0
  
  // 包含小写字母
  if (/[a-z]/.test(password)) score += 1
  // 包含大写字母
  if (/[A-Z]/.test(password)) score += 1
  // 包含数字
  if (/\d/.test(password)) score += 1
  // 包含特殊字符
  if (/[!@#$%^&*(),.?":{}|<>]/.test(password)) score += 1
  // 长度大于等于8
  if (password.length >= 8) score += 1
  
  if (score >= 3 && password.length >= 6) {
    result.valid = true
  }
  
  if (score <= 2) {
    result.level = 'weak'
    result.tips.push('建议包含大小写字母、数字和特殊字符')
  } else if (score <= 3) {
    result.level = 'medium'
  } else {
    result.level = 'strong'
  }
  
  return result
}

/**
 * 生成随机字符串
 * @param {number} length 长度
 * @returns {string} 随机字符串
 */
export const generateRandomString = (length = 8) => {
  const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'
  let result = ''
  for (let i = 0; i < length; i++) {
    result += chars.charAt(Math.floor(Math.random() * chars.length))
  }
  return result
}

/**
 * 获取文件扩展名
 * @param {string} filename 文件名
 * @returns {string} 扩展名
 */
export const getFileExtension = (filename) => {
  if (!filename) return ''
  const dotIndex = filename.lastIndexOf('.')
  return dotIndex > -1 ? filename.substring(dotIndex + 1).toLowerCase() : ''
}

/**
 * 格式化文件大小
 * @param {number} size 文件大小（字节）
 * @returns {string} 格式化后的文件大小
 */
export const formatFileSize = (size) => {
  if (!size && size !== 0) return '0 B'
  const units = ['B', 'KB', 'MB', 'GB', 'TB']
  let index = 0
  let fileSize = size
  
  while (fileSize >= 1024 && index < units.length - 1) {
    fileSize /= 1024
    index++
  }
  
  return `${fileSize.toFixed(index === 0 ? 0 : 1)} ${units[index]}`
}

/**
 * URL参数解析
 * @param {string} url URL字符串
 * @returns {object} 参数对象
 */
export const parseUrlParams = (url) => {
  const params = {}
  const urlParts = url.split('?')
  if (urlParts.length < 2) return params
  
  const queryString = urlParts[1]
  const pairs = queryString.split('&')
  
  pairs.forEach(pair => {
    const [key, value] = pair.split('=')
    if (key) {
      params[decodeURIComponent(key)] = decodeURIComponent(value || '')
    }
  })
  
  return params
}

/**
 * 对象转URL参数
 * @param {object} params 参数对象
 * @returns {string} URL参数字符串
 */
export const objectToParams = (params) => {
  if (!params || typeof params !== 'object') return ''
  
  const pairs = []
  Object.keys(params).forEach(key => {
    const value = params[key]
    if (value !== null && value !== undefined && value !== '') {
      pairs.push(`${encodeURIComponent(key)}=${encodeURIComponent(value)}`)
    }
  })
  
  return pairs.join('&')
}

/**
 * 获取平台信息
 * @returns {object} 平台信息
 */
export const getPlatform = () => {
  const systemInfo = uni.getSystemInfoSync()
  return {
    platform: systemInfo.platform, // ios, android, windows, mac
    system: systemInfo.system, // 操作系统及版本
    version: systemInfo.version, // 微信版本号
    SDKVersion: systemInfo.SDKVersion, // 基础库版本
    brand: systemInfo.brand, // 设备品牌
    model: systemInfo.model, // 设备型号
    screenWidth: systemInfo.screenWidth,
    screenHeight: systemInfo.screenHeight,
    windowWidth: systemInfo.windowWidth,
    windowHeight: systemInfo.windowHeight,
    statusBarHeight: systemInfo.statusBarHeight,
    safeArea: systemInfo.safeArea,
    safeAreaInsets: systemInfo.safeAreaInsets
  }
}

/**
 * 获取导航栏高度
 * @returns {number} 导航栏高度
 */
export const getNavBarHeight = () => {
  const systemInfo = getPlatform()
  // #ifdef MP-WEIXIN
  const menuButtonInfo = uni.getMenuButtonBoundingClientRect()
  return menuButtonInfo.height + (menuButtonInfo.top - systemInfo.statusBarHeight) * 2
  // #endif
  
  // #ifdef APP-PLUS
  return systemInfo.statusBarHeight + 44
  // #endif
  
  // #ifdef H5
  return 44
  // #endif
  
  return 44
}

/**
 * 获取底部安全区域高度
 * @returns {number} 底部安全区域高度
 */
export const getSafeAreaBottom = () => {
  const systemInfo = getPlatform()
  return systemInfo.safeAreaInsets ? systemInfo.safeAreaInsets.bottom : 0
}